#!/bin/bash
# Description: Verify mock generation configuration consistency

# Check if Makefile target matches the new mock path
echo "Checking Makefile mock generation target..."
rg "mock.*Executor" Makefile

# Verify mock output directory exists
if [ -d "mocks" ]; then
    echo "Checking current mock files..."
    ls -la mocks/mock_Executor.go 2>/dev/null || echo "Warning: mock_Executor.go not found"
    # Check for any leftover old mock files
    ls -la mocks/mock_Execute.go 2>/dev/null && echo "Warning: Old mock file still exists"
fi

#!/bin/bash
# Let's verify the interface definition and mock generation setup

# Check the interface definition
echo "Checking interface definition..."
rg -A 5 "type Executor interface" 

# Check mockery configuration
echo -e "\nChecking mockery configuration..."
cat .mockery.yaml

# Check if there are any references to old interface names
echo -e "\nChecking for old interface references..."
rg "Execute interface" 

#!/bin/bash
# Description: Check for any remaining references to old naming pattern
# and verify consistency of new naming pattern

# Check for any remaining "Execute" references in test files
echo "Checking for old 'Execute' references in test files:"
rg -l 'Execute' 'test/**/*_test.go'

# Check the new naming pattern usage
echo -e "\nVerifying new 'Executor' naming pattern:"
rg -l 'Executor' 'test/**/*_test.go'

#!/bin/bash
# Let's first find the correct test directory structure
fd -t f ".*_test.go$"

# Then search for Execute and Executor patterns in all test files
echo -e "\nChecking for 'Execute' references:"
rg -l "Execute" $(fd -t f ".*_test.go$")

echo -e "\nVerifying 'Executor' naming pattern:"
rg -l "Executor" $(fd -t f ".*_test.go$")

#!/bin/bash
# Let's check the actual usage context of Execute and Executor in the files
echo "Context for 'Execute' in jsonrpc/client_server_test.go:"
rg -C 3 "Execute" proxy/jsonrpc/client_server_test.go

echo -e "\nContext for 'Executor' in test files:"
for file in proxy/grpc/client_server_test.go proxy/grpc/proxy_test.go proxy/jsonrpc/proxy_test.go proxy/jsonrpc/client_server_test.go test/dummy_test.go; do
    echo -e "\n=== $file ==="
    rg -C 3 "Executor" "$file"
done

#!/bin/bash
# Description: Verify no remaining references to the old interface name
# Test 1: Search for any remaining "Execute" interface references
rg -l "type\s+Execute\s+interface"

# Test 2: Search for any remaining mock references
rg -l "NewMockExecute"

# Test 3: Verify the interface is properly used in server implementations
ast-grep --pattern 'type Server struct {
  $$$
  executor Executor
  $$$
}'

#!/bin/bash
# Let's try a broader search strategy

# Search for any references to "Execute" or "Executor" interface
rg -i "execute[r]?\s+interface" -A 2

# Search for struct fields or method parameters using Execute/Executor
rg -i "execute[r]?[\s,\)]" -A 2

# Search for mock implementations
fd -e go mock --exec rg -l "Execute|Executor"

# Look for test files that might use the interface
fd -e go _test --exec rg -l "Execute|Executor"

#!/bin/bash
# Let's check the content of mock and test files to verify the interface usage

# Check mock implementation
cat ./mocks/mock_Executor.go | head -n 20

# Check usage in test files
echo "=== proxy_test.go ==="
rg "Execute|Executor" ./proxy/jsonrpc/proxy_test.go -B 1 -A 1

echo "=== client_server_test.go ==="
rg "Execute|Executor" ./proxy/jsonrpc/client_server_test.go -B 1 -A 1

echo "=== grpc test files ==="
rg "Execute|Executor" ./proxy/grpc/proxy_test.go -B 1 -A 1
rg "Execute|Executor" ./proxy/grpc/client_server_test.go -B 1 -A 1

#!/bin/bash
# Description: Check for any remaining references to ExecuteSuite and verify ExecutorSuite usage

# Test 1: Search for any remaining references to old name
echo "Checking for remaining ExecuteSuite references:"
rg "ExecuteSuite"

# Test 2: Verify ExecutorSuite usage is consistent
echo "Verifying ExecutorSuite usage:"
rg "ExecutorSuite"

#!/bin/bash
# Let's try a different approach to search for ExecuteSuite/ExecutorSuite

# Search for any file containing Execute or Executor with Suite
echo "Searching for Execute/Executor Suite references:"
rg -i "execute.*suite|executor.*suite" -A 2 -B 2

# Also check for any struct definitions containing these terms
echo "Checking struct definitions:"
ast-grep --pattern 'type $_ struct {
  $$$
  ExecuteSuite
  $$$
}'

echo "And:"
ast-grep --pattern 'type $_ struct {
  $$$
  ExecutorSuite
  $$$
}'

#!/bin/bash
# Description: Verify that all references to 'Execute' interface have been updated to 'Executor'

# Test 1: Search for any remaining references to the old interface name
# Expect: No matches for the old interface name pattern
echo "Checking for remaining 'Execute' interface references..."
rg -l 'type\s+Execute\s+interface' || true

# Test 2: Verify the new interface name exists
# Expect: At least one match for the new interface name
echo "Verifying 'Executor' interface definition exists..."
rg -l 'type\s+Executor\s+interface'

# Test 3: Check for any potentially missed Execute references in test files
# Expect: No matches except in words like "Execute" in comments/strings
echo "Checking test files for missed references..."
rg 'Execute' 'test/'

#!/bin/bash
# Let's do a comprehensive check for any remaining references to 'Execute' that might be interface-related

# Check for any Execute-related type definitions or interface methods
ast-grep --pattern 'type Execute'

# Check for any Execute-related interface implementations or method definitions
ast-grep --pattern 'func ($x *$_) Execute'

# Check for any Execute variable declarations or assignments
rg -p 'Execute\s*:=' || true

# Look for any Execute-related imports or package references
rg -p '\".*Execute.*\"' || true

# Check for Execute in method calls or variable usage
rg -p '\.Execute\(' || true

#!/bin/bash
# Comprehensive check with corrected patterns

# Check for any Execute-related imports
rg -p '"[^"]*Execute[^"]*"'

# Check interface definition in execution.go
cat execution.go

# Check for any Execute method calls
rg -p '\bExecute\b' --type go

# Check for any Execute type references
rg -p '\bExecute\s+\w+' --type go

#!/bin/bash
# Description: Verify that DummyExecutor implements all methods of the Executor interface

# Test: Search for the Executor interface definition and compare with DummyExecutor methods
echo "=== Executor interface definition ==="
ast-grep --pattern 'type Executor interface {
  $$$
}'

echo -e "\n=== DummyExecutor methods ==="
ast-grep --pattern 'func (e *DummyExecutor) $_($$$) $$$'

#!/bin/bash
# Description: Verify the consistency of constructor usage across test files
# Expected: All test files should use NewDummyExecutor, not NewExecute

# Check for any remaining references to the old constructor
echo "Checking for old constructor references:"
rg "NewExecute\(" -t go

# Check the usage pattern of the new constructor
echo -e "\nVerifying new constructor usage:"
rg "NewDummyExecutor\(" -t go

#!/bin/bash
# Description: Verify the mock implementation exists and contains the expected interface name
# Expected: Find the mock file with Executor interface

# Test 1: Check if the mock file exists
fd -t f "mock_Executor.go" mocks/

# Test 2: Verify the interface name in the mock
rg -l "type Executor interface" 

#!/bin/bash
# Let's verify the mock implementation matches the interface definition

# First, get the interface definition
rg -A 5 "type Executor interface" execution.go

# Then, check the mock implementation
cat mocks/mock_Executor.go

#!/bin/bash
# Search for NewServer function calls to ensure they use the new Executor interface
rg -A 3 "NewServer\(" 

#!/bin/bash
# Search for mock executor implementations
rg -B 2 -A 2 "type mock.*Exec" 

#!/bin/bash
# Search for mock executor variable declarations and struct definitions in test files
rg -B 2 -A 2 "(var|type).*mock.*exec" --ignore-case

# Also search for mock.Mock implementations which are commonly used in Go tests
rg -B 2 -A 2 "mock\.Mock" 

#!/bin/bash
# Description: Verify mock regeneration and interface usage
# Test 1: Check if the old mock file is removed
if [ -f "mocks/mock_Execute.go" ]; then
    echo "Error: Old mock file still exists"
    exit 1
fi

# Test 2: Verify new mock file exists and contains Executor interface
rg -l "type Executor interface" 
rg -l "type MockExecutor struct"

# Test 3: Check for any remaining references to the old Execute interface
rg -l "Execute interface"

#!/bin/bash
# Let's verify the mock implementation and usage more thoroughly

# Check the content of the mock file
echo "=== Mock Implementation ==="
cat mocks/mock_Executor.go

# Check the test file implementation
echo -e "\n=== Test Implementation ==="
cat proxy/jsonrpc/client_server_test.go

# Check interface definition
echo -e "\n=== Interface Definition ==="
cat execution.go

#!/bin/bash
# Search for any remaining references to the old "Execute" interface name
rg -i "execution\.Execute" --type go

#!/bin/bash
# Let's check the content of these matches to understand if they are related to interface naming
rg -A 5 -B 5 "ExecuteTxs" types/pb/execution/execution.pb.go

#!/bin/bash
# Let's verify if there are any direct references to the interface type "Execute"
rg -w "Execute" --type go | grep -v "ExecuteTxs"